{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/xmj/anaconda3/lib/python3.6/site-packages/h5py/__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "38\n"
     ]
    }
   ],
   "source": [
    "from __future__ import absolute_import\n",
    "from __future__ import division\n",
    "from __future__ import print_function\n",
    "import matplotlib.pyplot as plt\n",
    "import random\n",
    "import time\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import cv2\n",
    "import model\n",
    "import utils\n",
    "import pickle\n",
    "import gc\n",
    "from utils import decode_sparse_tensor, sparse_tuple_from"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 加载word tocken\n",
    "word2idx = pickle.load(open('./word2idx3.pkl', 'rb'))\n",
    "idx2word = pickle.load(open('./idx2word3.pkl', 'rb'))\n",
    "temp_arr = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def random_cut(image, w=800, h=40):\n",
    "    ih, iw = image.shape\n",
    "    x_start = random.randint(0, iw - w)\n",
    "    y_start = random.randint(0, ih - h)\n",
    "    return image[y_start:y_start+h, x_start:x_start+w]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_train_set(my_seq_len = 89, max_label_width=28, output_length = 200000):\n",
    "    for key in word2idx:\n",
    "        temp_arr.append(word2idx[key])\n",
    "    label_max = max(temp_arr)\n",
    "    label_max += 1\n",
    "    print(label_max)\n",
    "    #加载数据集\n",
    "    cut_zhuanzhe = lambda m: m.split('\\n')[0]\n",
    "    file_lst = list(map(cut_zhuanzhe, open('../temp.lst').readlines()))\n",
    "    np.random.shuffle(file_lst)\n",
    "    start_idx = 0\n",
    "    while True:\n",
    "        end_idx = min(len(file_lst), start_idx + output_length)\n",
    "        image_arr = []\n",
    "        label_arr = []\n",
    "        idx = 0\n",
    "        seq_len_arr = []\n",
    "        for f in file_lst[start_idx:end_idx]:\n",
    "            image = cv2.imread('../'+f, 0)\n",
    "        #     image = np.array(image[:,:500,:])\n",
    "            label = list(map(int, f.split('/')[-1].split('_')[1].split('-')))\n",
    "            while len(label) < max_label_width:\n",
    "                label.append(label_max)\n",
    "            image_arr.append(image)\n",
    "            label_arr.append(label)\n",
    "            seq_len_arr.append(my_seq_len)\n",
    "            idx += 1\n",
    "        start_idx +=  output_length\n",
    "        if start_idx >= len(file_lst) - 10000:\n",
    "            start_idx = 0    \n",
    "            np.random.shuffle(file_lst)\n",
    "\n",
    "        gc.collect()\n",
    "        label_targets = [np.asarray(i) for i in label_arr]\n",
    "        yield image_arr, label_targets, seq_len_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def build_model():\n",
    "    num_hidden = 256\n",
    "    num_layers = 1\n",
    "    for key in word2idx:\n",
    "        temp_arr.append(word2idx[key])\n",
    "    num_classes = max(temp_arr) + 2\n",
    "    print(\"num_classes\", num_classes)\n",
    "    init_learning_rate = 0.001\n",
    "    global_step = tf.Variable(0, trainable=False)\n",
    "    learning_rate = tf.train.exponential_decay(init_learning_rate,\n",
    "                                               global_step,\n",
    "                                               10000,\n",
    "                                               0.9,\n",
    "                                               staircase=True)\n",
    "    inputs = tf.placeholder(tf.float32, [None, 40, None, 1])\n",
    "    targets = tf.sparse_placeholder(tf.int32)\n",
    "    seq_len = tf.placeholder(tf.int32, [None])\n",
    "    ################################CNN###################################\n",
    "    # Convolutional Layer #1\n",
    "    conv1 = tf.layers.conv2d(\n",
    "      inputs=inputs,\n",
    "      filters=64,\n",
    "      kernel_size=[3, 3],\n",
    "      padding=\"same\",\n",
    "      activation=tf.nn.relu)\n",
    "    # Convolutional Layer #2 and Pooling Layer #2 19\n",
    "    conv2 = tf.layers.conv2d(\n",
    "      inputs=conv1,\n",
    "      filters=64,\n",
    "      kernel_size=[3, 3],\n",
    "      padding=\"same\",\n",
    "      activation=tf.nn.relu)\n",
    "    pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)\n",
    "    print(pool2.get_shape())\n",
    "    # Convolutional Layer #3 and Pooling Layer #3 9\n",
    "    conv3 = tf.layers.conv2d(\n",
    "      inputs=pool2,\n",
    "      filters=128,\n",
    "      kernel_size=[3, 3],\n",
    "      padding=\"same\",\n",
    "      activation=tf.nn.relu)\n",
    "    conv3 = tf.layers.conv2d(\n",
    "      inputs=conv3,\n",
    "      filters=128,\n",
    "      kernel_size=[3, 3],\n",
    "      padding=\"same\",\n",
    "      activation=tf.nn.relu)\n",
    "    pool3 = tf.layers.max_pooling2d(inputs=conv3, pool_size=[2, 2], strides=2)\n",
    "    print(pool3.get_shape())\n",
    "    conv4 = tf.layers.conv2d(\n",
    "      inputs=pool3,\n",
    "      filters=256,\n",
    "      kernel_size=[3, 3],\n",
    "      padding=\"valid\",\n",
    "      activation=tf.nn.relu)\n",
    "    pool4 = tf.layers.max_pooling2d(inputs=conv4, pool_size=[2, 2], strides=[2,1])\n",
    "    print(pool4.get_shape())\n",
    "    conv5 = tf.layers.conv2d(\n",
    "      inputs=pool4,\n",
    "      filters=512,\n",
    "      kernel_size=[3, 5],\n",
    "      padding=\"valid\",\n",
    "      activation=tf.nn.relu)\n",
    "    print(conv5.get_shape())\n",
    "    ######################################################################\n",
    "#     def lstm_cell():\n",
    "#         return tf.contrib.rnn.LSTMCell(num_hidden)\n",
    "#     stack = tf.contrib.rnn.MultiRNNCell([lstm_cell() for _ in range(0, num_layers)],\n",
    "#                                             state_is_tuple=True)\n",
    "\n",
    "    # The second output is the last state and we will no use that\n",
    "    features = tf.transpose(conv5, (0, 2, 1, 3))\n",
    "    shape = tf.shape(features)\n",
    "    features = tf.reshape(features, [shape[0], shape[1], 2*512])\n",
    "    batch_s, max_timesteps = shape[0], shape[1]\n",
    "#     outputs, _ = tf.nn.dynamic_rnn(stack, features, seq_len, dtype=tf.float32)\n",
    "    # Reshaping to apply the same weights over the timesteps\n",
    "    outputs = tf.reshape(features, [-1, 1024])\n",
    "    logits = tf.layers.dense(inputs=outputs, units = num_classes)\n",
    "    logits = tf.reshape(logits, [batch_s, -1, num_classes])\n",
    "    # Time major\n",
    "    logits = tf.transpose(logits, (1, 0, 2))\n",
    "    #######################################################################\n",
    "\n",
    "    print(logits.get_shape())\n",
    "    loss = tf.nn.ctc_loss(targets, logits, seq_len, preprocess_collapse_repeated=False, ctc_merge_repeated=False)\n",
    "    cost = tf.reduce_mean(loss)\n",
    "\n",
    "    optimizer = tf.train.AdamOptimizer(learning_rate).minimize(cost, global_step=global_step)\n",
    "\n",
    "    # Option 2: tf.contrib.ctc.ctc_beam_search_decoder\n",
    "    # (it's slower but you'll get better results)\n",
    "    decoded, log_prob = tf.nn.ctc_beam_search_decoder(logits, seq_len, merge_repeated=False)\n",
    "\n",
    "    # Accuracy: label error rate\n",
    "    acc = tf.reduce_mean(tf.edit_distance(tf.cast(decoded[0], tf.int32), targets))\n",
    "    return inputs, targets, seq_len, cost, optimizer, acc, decoded, global_step, learning_rate, log_prob"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def do_report():\n",
    "    test_feed = {inputs: train_inputs, targets: train_targets, seq_len: train_seq_len}\n",
    "    dd, log_probs, accuracy = session.run([decoded[0], log_prob, acc], test_feed)\n",
    "    print('acc:', 1-accuracy)\n",
    "#     report_accuracy(dd, test_targets)\n",
    "    # decoded_list = decode_sparse_tensor(dd)\n",
    "\n",
    "def do_batch():\n",
    "    feed = {inputs: train_inputs, targets: train_targets, seq_len: train_seq_len}\n",
    "    b_cost, steps, _ = session.run([cost, global_step, optimizer], feed)\n",
    "    if steps > 0 and steps % 1000 == 0:\n",
    "#         do_report()\n",
    "        save_path = saver.save(session, \"models/ocr_fcn3.model\", global_step=steps)\n",
    "        #print(save_path)\n",
    "    return b_cost, steps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    del train_arr, train_labels, train_seq_arr, train_iter\n",
    "    gc.collect()\n",
    "except:\n",
    "    None\n",
    "train_iter = load_train_set(192)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "num_classes 1806\n",
      "(?, 20, ?, 64)\n",
      "(?, 10, ?, 128)\n",
      "(?, 4, ?, 256)\n",
      "(?, 2, ?, 512)\n",
      "(?, ?, 1806)\n"
     ]
    }
   ],
   "source": [
    "config = tf.ConfigProto()\n",
    "config.gpu_options.allow_growth = True\n",
    "session = tf.Session(config=config)\n",
    "inputs, targets, seq_len, cost, optimizer, acc, decoded, global_step, learning_rate, log_prob = build_model()\n",
    "# Initializate the weights and biases\n",
    "init = tf.global_variables_initializer()\n",
    "session.run(init)\n",
    "saver = tf.train.Saver(tf.global_variables(), max_to_keep=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(33, 1275)\n"
     ]
    }
   ],
   "source": [
    "img = cv2.imread('../temp_img.jpg',0)# '../images/img_1946-1602-1553-1910-285_399816.jpg') # )'../images/img_1946-1602-1553-1910-285_399816.jpg'\n",
    "print(img.shape)\n",
    "h, w = img.shape\n",
    "bili = 30 * 1.0 / h\n",
    "aim_h = 30\n",
    "aim_w = int(bili * w)\n",
    "gray = img\n",
    "ret, gray = cv2.threshold(gray, 126, 255, cv2.THRESH_BINARY)\n",
    "img2 = cv2.cvtColor(gray, cv2.COLOR_GRAY2BGR)\n",
    "img2 = cv2.resize(img, (aim_w, aim_h))\n",
    "h, w = img2.shape\n",
    "img3 = np.ones([40, w], np.uint8) * 255\n",
    "img3[5:35,:] = img2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Restoring parameters from ./models/ocr_fcn3.model-845000\n",
      "start\n",
      "1805\n",
      "Epoch....... 0\n",
      "200000\n",
      "Step: 845001 , batch seconds: 0.20255613327026367 , loss: 0.005928373\n",
      "Step: 845101 , batch seconds: 0.15399861335754395 , loss: 0.009458366\n",
      "Step: 845201 , batch seconds: 0.15421724319458008 , loss: 0.47775587\n",
      "Step: 845301 , batch seconds: 0.15620779991149902 , loss: 0.10573561\n",
      "Step: 845401 , batch seconds: 0.15492868423461914 , loss: 0.15893134\n",
      "Step: 845501 , batch seconds: 0.15461015701293945 , loss: 0.09067988\n",
      "Step: 845601 , batch seconds: 0.15349864959716797 , loss: 0.036978647\n",
      "Step: 845701 , batch seconds: 0.15533113479614258 , loss: 0.011060311\n",
      "Step: 845801 , batch seconds: 0.15709280967712402 , loss: 0.084078304\n",
      "Step: 845901 , batch seconds: 0.15478038787841797 , loss: 2.4156327\n"
     ]
    }
   ],
   "source": [
    "batch_size = 1\n",
    "num_epochs = 10000\n",
    "saver.restore(session, './models/ocr_fcn3.model-845000')\n",
    "print('start')\n",
    "for curr_epoch in range(num_epochs):\n",
    "#     if curr_epoch % 10 == 1 and batch_size < 32:\n",
    "#         batch_size = int(batch_size * 2) + 2\n",
    "#     else:\n",
    "#         batch_size = int(batch_size / 8) + 2\n",
    "    train_arr, train_labels, train_seq_arr = next(train_iter)\n",
    "    print(\"Epoch.......\", curr_epoch)\n",
    "    print(len(train_arr))\n",
    "    train_cost = train_ler = 0\n",
    "    for batch in range(int(len(train_arr)/batch_size) - 1):\n",
    "        start = time.time()\n",
    "        train_inputs = np.array(list(map(random_cut, train_arr[batch*batch_size:(batch+1)*batch_size])))[:,:,:,np.newaxis]\n",
    "        train_targets = sparse_tuple_from(train_labels[batch*batch_size:(batch+1)*batch_size])\n",
    "        train_seq_len = train_seq_arr[batch*batch_size:(batch+1)*batch_size]\n",
    "        #print(\"get data time\", time.time() - start)\n",
    "        start = time.time()\n",
    "        c, steps = do_batch()\n",
    "        train_cost += c * batch_size\n",
    "        seconds = time.time() - start\n",
    "        if batch % 100 == 0:\n",
    "            print(\"Step:\", steps, \", batch seconds:\", seconds,\", loss:\", c)\n",
    "        \n",
    "        try:\n",
    "            if c < 0.001:\n",
    "                print(c)\n",
    "                break;\n",
    "        except:\n",
    "            print(c)\n",
    "            break;\n",
    "    decoded_ = session.run(decoded, feed_dict={inputs: np.array([img3[:,:,np.newaxis]]),seq_len:np.array([280])})\n",
    "    output = [] #\n",
    "    for v in decoded_[0][1]:\n",
    "        output.append(idx2word[v])\n",
    "    print(''.join(output))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 测试代码"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "num_classes 1806\n",
      "(?, 20, ?, 64)\n",
      "(?, 10, ?, 128)\n",
      "(?, 4, ?, 256)\n",
      "(?, 2, ?, 512)\n",
      "(?, ?, 1806)\n",
      "INFO:tensorflow:Restoring parameters from ./models/ocr_fcn3.model-845000\n"
     ]
    }
   ],
   "source": [
    "config = tf.ConfigProto()\n",
    "config.gpu_options.allow_growth = True\n",
    "session = tf.Session(config=config)\n",
    "inputs, targets, seq_len, cost, optimizer, acc, decoded, global_step, learning_rate, log_prob = build_model()\n",
    "saver = tf.train.Saver()\n",
    "saver.restore(session, './models/ocr_fcn3.model-845000')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(33, 1275, 3)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f7b09292f28>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(40, 1545, 3)\n"
     ]
    }
   ],
   "source": [
    "# 使用fcn模型进行预测\n",
    "img = cv2.imread('./images_result/test.jpg')# )'../images/img_1946-1602-1553-1910-285_399816.jpg'\n",
    "print(img.shape)\n",
    "h, w, _ = img.shape\n",
    "bili = 40 * 1.0 / h\n",
    "aim_h = 40\n",
    "aim_w = int(bili * w)\n",
    "img2 = cv2.resize(img, (aim_w, aim_h))\n",
    "gray = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)\n",
    "ret, gray = cv2.threshold(gray, 128, 255, cv2.THRESH_BINARY)\n",
    "img2 = cv2.cvtColor(gray, cv2.COLOR_GRAY2BGR)\n",
    "plt.figure(figsize=(30, 10))\n",
    "plt.imshow(img2)\n",
    "plt.show()\n",
    "print(img2.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f7b092927b8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(40, 1275, 3)\n"
     ]
    }
   ],
   "source": [
    "img2 = np.ones([40, 1275, 3], np.uint8) * 255\n",
    "img2[3:36,:,:] = img\n",
    "plt.figure(figsize=(30, 10))\n",
    "plt.imshow(img2)\n",
    "plt.show()\n",
    "print(img2.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(33, 1275)\n"
     ]
    }
   ],
   "source": [
    "img = cv2.imread('./images_result/test.jpg',0)# '../images/img_1946-1602-1553-1910-285_399816.jpg') # )'../images/img_1946-1602-1553-1910-285_399816.jpg'\n",
    "print(img.shape)\n",
    "h, w = img.shape\n",
    "bili = 30 * 1.0 / h\n",
    "aim_h = 30\n",
    "aim_w = int(bili * w)\n",
    "gray = img\n",
    "ret, gray = cv2.threshold(gray, 126, 255, cv2.THRESH_BINARY)\n",
    "img2 = cv2.cvtColor(gray, cv2.COLOR_GRAY2BGR)\n",
    "img2 = cv2.resize(img, (aim_w, aim_h))\n",
    "h, w = img2.shape\n",
    "img3 = np.ones([40, w], np.uint8) * 255\n",
    "img3[5:35,:] = img2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "decoded_ = session.run(decoded, feed_dict={inputs: np.array([img3[:,:,np.newaxis]]),seq_len:np.array([280])})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "由消防控制室接蝴板引至各消防电子设备的专用接地线应选通信绝缘导线,其线芯截面面树不应于4m㎡\n"
     ]
    }
   ],
   "source": [
    "output = [] #\n",
    "for v in decoded_[0][1]:\n",
    "    output.append(idx2word[v])\n",
    "print(''.join(output))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(decoded_[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(30, 10))\n",
    "plt.imshow(img2)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
